home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1995 April / Internet Tools.iso / applic / ncsa / Mac / Telnet2.6 / prerelease / d3 / Telnet2.6.1d3.src.sit.hqx / Telnet 2.6.1d3 source / source / tek / tekrgmac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-19  |  12.6 KB  |  589 lines
  1. /*
  2. rgmac.c by Gaige B. Paulsen
  3.   spawned from rgp.c by Aaron Contorer for NCSA
  4. Copyright 1987, board of trustees, University of Illinois
  5.  
  6. Routines for Macintosh Window output.  
  7. */
  8.  
  9. #ifdef MPW
  10. #pragma segment TEKMAIN
  11. #endif
  12.  
  13. #include <stdio.h>
  14. #include <String.h>
  15. #include <Packages.h>
  16.  
  17. #include "tekrgmac.proto.h"
  18. #include "TelnetHeader.h"
  19. #include "maclook.proto.h"
  20. #include "vgtek.proto.h"
  21. #include "mydnr.proto.h"
  22. #include "rsmac.proto.h"
  23. #include "netevent.proto.h"
  24. #include "rg0.proto.h"
  25. #include "rgmp.proto.h"
  26. #include "InternalEvents.h"
  27. #include "tekdefs.h"        /* NCSA: sb - all the TEK defines are now here */
  28.  
  29. #define TEK_DEBUG1
  30. #ifdef    TEK_DEBUG1
  31. #include "debug.h"
  32. #define    TEK_DEBUG_PRINT(x)    putln(x)
  33. char    TEK_DEBUG_STRING    [512];
  34. #else
  35. #define    TEK_DEBUG(x)
  36. #endif
  37.  
  38. /*--------------------------------------------------------------------------*/
  39. /* Some variable definitions are needed before we give the code                */
  40. /*                                                                             */
  41. /*--------------------------------------------------------------------------*/
  42.  
  43. long    RGMlastclick;
  44. short    RGMcolor[]=
  45.     { 30,            /* black */
  46.       33,            /* white */
  47.       205,            /* red */
  48.       341,            /* green */
  49.       409,            /* blue */
  50.       273,            /* cyan */
  51.       137,            /* magenta */
  52.       69            /* yellow */
  53.       };
  54.  
  55. struct    RGMwindows *RGMwind[ MAXWIND ];
  56.  
  57. char    *RGMdevname(void)
  58. {
  59.     return("Macintosh Windows");
  60. }
  61.  
  62. short    RGMnewwin(void)
  63. {
  64.     short    i = 0;
  65.  
  66.     while ((i < MAXWIND) && (RGMwind[i]->inuse)) i++;
  67.  
  68.     if (i >= MAXWIND) return(-1);
  69.  
  70.     RGMwind[i]->wind = GetNewWindow(256, NULL, kInFront);
  71.     if (RGMwind[i]->wind == 0L) return(-1);
  72.  
  73.     ((WindowPeek)RGMwind[i]->wind)->windowKind = WIN_TEK;
  74.     
  75.     RGMwind[i]->vg = -1;                /* BYU */
  76.     RGMwind[i]->vs = -1;                /* BYU */
  77.     RGMwind[i]->xorigin = 0;
  78.     RGMwind[i]->yorigin = 0;
  79.     RGMwind[i]->xscale  = WINXMAX;    /* BYU LSC - need the "W" here */
  80.     RGMwind[i]->yscale  = WINYMAX;    /* BYU LSC - need the "W" here */
  81.     RGMwind[i]->width   = 400;        /* BYU LSC - was 256 (size of old window resource */
  82.     RGMwind[i]->height  = 300;        /* BYU LSC - was 342 (size of old window resource */
  83.     RGMwind[i]->inuse   = TRUE;
  84.     RGMwind[i]->ingin   = 0;        /* BYU LSC */
  85.  
  86.     ValidRect(&RGMwind[i]->wind->portRect);  
  87.  
  88.     return(i);
  89. }
  90.  
  91. void    RGMinit(void)
  92. {
  93.     short    i;
  94.     for (i = 0; i < MAXWIND; i++)
  95.         RGMwind[i]->inuse = 0;
  96. }
  97.  
  98. short    RGMgin(short w)
  99. {
  100.     if (RGsetwind(w)) return(-1);
  101.  
  102.     setgraphcurs();
  103.     RGMwind[w]->ingin=1;
  104. }
  105.  
  106. short    RGMpencolor(short w, short color)
  107. {
  108.     if (RGsetwind(w) ) return(-1);
  109.     ForeColor((long) RGMcolor[color] );
  110. #ifdef    TEK_DEBUG_1
  111.     sprintf(TEK_DEBUG_STRING, "TEK: Setting pen color to %d", color);
  112.     putln(TEK_DEBUG_STRING);
  113. #endif
  114.  
  115. }
  116.  
  117. short    RGMclrscr(short w)
  118. {    
  119.     if (RGsetwind(w) ) return(-1);
  120.     PaintRect(&RGMwind[w]->wind->portRect);
  121.     TEK_DEBUG_PRINT("TEK: Clearing screen");                    
  122. }    
  123.  
  124. short    RGMclose(short w)
  125. {
  126.     if (RGsetwind(w) ) return(-1);
  127.  
  128.     DisposeWindow(RGMwind[w]->wind);
  129.     RGMwind[w]->inuse  = FALSE;
  130. }
  131.  
  132. short    RGMpoint(short w, short x, short y)
  133. {
  134.     if (RGsetwind(w) ) return(-1);
  135.  
  136.     MoveTo(x,y);
  137.     LineTo(x,y);
  138. } 
  139.  
  140. short    RGMdrawline(short w, short x0, short y0, short x1, short y1)
  141. {
  142.     long    xl0, yl0, xl1, yl1;
  143.     
  144.     if (RGsetwind(w) )
  145.         return(-1);
  146.  
  147.     xl0 = ((long)x0 * RGMwind[w]->width) / INXMAX;
  148.     yl0 = (long)RGMwind[w]->height - (((long)y0 * RGMwind[w]->height) / INYMAX);
  149.     xl1 = ((long)x1 * RGMwind[w]->width) / INXMAX;
  150.     yl1 = (long)RGMwind[w]->height - (((long)y1 * RGMwind[w]->height) / INYMAX);
  151.  
  152.     MoveTo((short)xl0, (short)yl0);
  153.     LineTo((short)xl1, (short)yl1);
  154. }
  155.  
  156. void    RGMinfo(short w, short v, short a, short b, short c, short d)
  157. {
  158.     UNUSED_ARG(a)
  159.     UNUSED_ARG(b)
  160.     UNUSED_ARG(c)
  161.     UNUSED_ARG(d)
  162.     RGMwind[w]->vg=v;
  163. }
  164.  
  165. void    RGMpagedone(short w)
  166. {
  167.     UNUSED_ARG(w)
  168. }
  169.  
  170. void    RGMdataline(short w, short data, short count)
  171. {
  172.     UNUSED_ARG(w)
  173.     UNUSED_ARG(data)
  174.     UNUSED_ARG(count)
  175. }
  176.  
  177.  
  178. void    RGMcharmode(short w, short rotation, short size)
  179. {
  180.     UNUSED_ARG(w)
  181.     UNUSED_ARG(rotation)
  182.     UNUSED_ARG(size)
  183. }
  184.  
  185. void    RGMgmode(void)
  186. {}
  187.  
  188. void    RGMtmode(void)
  189. {}
  190.  
  191. void    RGMshowcur(void)
  192. {
  193. }
  194.  
  195. void    RGMlockcur(void)
  196. {
  197. }
  198.  
  199. void    RGMhidecur(void)
  200. {
  201. }
  202.  
  203. void    RGMbell(short w)
  204. {
  205.     UNUSED_ARG(w)
  206. }
  207.  
  208. void    RGMuncover(short w)
  209. {
  210.     UNUSED_ARG(w)
  211. }
  212.  
  213. short    RGMoutfunc(short (*f )())
  214. {
  215.     UNUSED_ARG(f)
  216.     return(0);    // Unused
  217. }
  218.  
  219. Boolean RGMalloc(void)        /* BYU - allocate this structure to save global space */
  220. {
  221.     short i;
  222.     for(i=0; i<MAXWIND; i++) {        /* BYU */
  223.         RGMwind[i] = (struct RGMwindows *) NewPtrClear(sizeof(struct RGMwindows));    /* BYU */
  224.         if (RGMwind[i]) {                        /* BYU */
  225.             RGMwind[i]->wind = (GrafPtr) 0;        /* BYU */
  226.             RGMwind[i]->id = 'RGMW';
  227.             RGMwind[i]->vg = -1;                /* BYU - necessary */
  228.             RGMwind[i]->vs = -1;                /* BYU */
  229.             RGMwind[i]->inuse = 0;                /* BYU - necessary */
  230.         } else                                     /* BYU */
  231.             return (TRUE);                /* BYU - insufficient memory */
  232.     }
  233.     return(FALSE);
  234. }
  235.  
  236. short    RGsetwind(short dnum)
  237. {
  238.     if (dnum<0 || dnum>=MAXWIND) return(-1);
  239.  
  240.     if (!RGMwind[dnum]->inuse) return(-1);
  241.  
  242.     SetPort( RGMwind[dnum]->wind);
  243.     return(0);
  244. }
  245.  
  246. short    RGfindbyVG(short vg)
  247. {
  248.     short    i = 0;
  249.  
  250.     while ((i < MAXWIND) && ((!RGMwind[i]->inuse) || (RGMwind[i]->vg != vg)))
  251.         i++;
  252.     if (i >= MAXWIND) return(-1);
  253.     return(i);
  254. }
  255.  
  256. short    RGattach(short vg, short virt, char *name, short TEKtype)
  257. {
  258.     short            dnum;
  259.     unsigned long    time;
  260.     char            myname[256],ts[256];
  261.  
  262.     if ((dnum = RGfindbyVG(vg)) < 0) return(-1);
  263.  
  264.     RGMwind[dnum]->vs = virt;
  265.     RGMwind[dnum]->name = (unsigned char *) NewPtrClear((long) 256);        /* BYU LSC */
  266.  
  267.     if (RGMwind[dnum]->name == 0L) return(-2);
  268.  
  269.     myname[0] = 'Ñ';
  270.     if (TEKtype)
  271.         strcpy(&myname[1], "[4105] ");
  272.     else
  273.         strcpy(&myname[1], "[4014] ");
  274.         
  275.     strncpy(&myname[strlen(myname)],name,120);
  276.  
  277.     GetDateTime(&time);
  278.     IUTimeString(time,FALSE,(StringPtr) ts);        /* BYU LSC - Put time in the temp string */
  279.     p2cstr((StringPtr)ts);                                            /* BYU LSC */
  280.  
  281.     strncat(myname,"  ",2);                /* BYU - was 4 - Space, please */
  282.     strncat(myname,ts,64);                /* BYU - Place the time string at the end */
  283.     strcpy((char *) RGMwind[dnum]->name,myname);    /* BYU LSC */
  284.  
  285.     if (RGMwind[dnum]->wind != (GrafPtr) 0) {    /* BYU LSC */
  286.         c2pstr(myname);                            /* BYU LSC */
  287.         SetWTitle(RGMwind[dnum]->wind,(StringPtr)myname);    /* BYU LSC */
  288.     }
  289.  
  290.     return(0);
  291. }
  292.  
  293.  
  294. short    RGdetach( short vg)
  295. {
  296.         short    dnum;            /* BYU */
  297.         char    myname[256];            /* BYU LSC */
  298.  
  299.     if ((dnum = RGfindbyVG(vg)) < 0) return(-1);        /* BYU */
  300.     if (dnum >= MAXWIND)  return(-1);                    /* BYU */
  301.  
  302.     if (RGMwind[dnum]->vs != -1) {                                     /* BYU */
  303.         if (RGMwind[dnum]->wind != (GrafPtr) 0) {                    /* BYU */
  304. #if 1
  305.             strncpy((char *) RGMwind[dnum]->name,                /* BYU LSC */
  306.                     (char *) &RGMwind[dnum]->name[1],255);        /* BYU LSC */
  307.             strncpy(myname, (char *) RGMwind[dnum]->name,256);    /* BYU LSC */
  308.             c2pstr(myname);                                        /* BYU LSC */
  309.             SetWTitle(RGMwind[dnum]->wind,(StringPtr)myname);                /* BYU LSC */
  310. #else
  311.             strncpy((char *) RGMwind[dnum]->name,                /* BYU LSC */
  312.                     (char *) &RGMwind[dnum]->name[1],255);        /* BYU LSC */
  313.             SetWTitle(RGMwind[dnum]->wind,RGMwind[dnum]->name);    /* BYU LSC */
  314. #endif
  315.         }                            /* BYU */
  316.     }                                /* BYU */
  317.     return(0);                        /* BYU */
  318. }
  319.  
  320. short    RGfindbywind( GrafPtr wind)
  321. {
  322.     short    i = 0;
  323.  
  324.     while ((i < MAXWIND) && ((!RGMwind[i]->inuse) || (RGMwind[i]->wind != wind)))
  325.         i++;
  326.     if (i >= MAXWIND) return(-1);
  327.     return(i);
  328. }
  329.  
  330. short    RGupdate( GrafPtr wind)
  331. {
  332.     short    i = 0,
  333.             done;
  334.  
  335.     if ((i = RGfindbywind(wind)) < 0)
  336.         return(-1);
  337.  
  338.     SetPort(wind);
  339.     BeginUpdate(wind);
  340.  
  341.     VGstopred(RGMwind[i]->vg);
  342.     VGpage(RGMwind[i]->vg);
  343.     done = VGpred(RGMwind[i]->vg,RGMwind[i]->vg);
  344.  
  345.     EndUpdate(wind);
  346.     if (!done)
  347.         netputevent(USERCLASS,RG_REDRAW,RGMwind[i]->vg,0);
  348.     return(done);
  349. }
  350.  
  351. short    RGsupdate( short i)
  352. {
  353.     short    rg;
  354.  
  355.     rg = RGfindbyVG(i);
  356.  
  357.     if (rg < 0) return(0);
  358.     SetPort(RGMwind[rg]->wind);
  359.     if (!VGpred(RGMwind[rg]->vg,RGMwind[rg]->vg))
  360.     {
  361.         netputevent(USERCLASS,RG_REDRAW,i,0);
  362.     }
  363.     else
  364.         return(1);
  365.     return(0);
  366. }
  367.  
  368. short    RGgetVG(GrafPtr wind)
  369. {
  370.     short    i;
  371.  
  372.     i = RGfindbywind(wind);
  373.  
  374.     return(RGMwind[i]->vg);
  375. }
  376.  
  377. short    RGgetdnum(GrafPtr wind)
  378. {
  379.     return(RGfindbywind(wind));
  380. }
  381.  
  382. short    RGgetVS(short dnum)
  383. {
  384.     return(RGMwind[dnum]->vs);
  385. }
  386.  
  387. short    inSplash(Point *p1, Point *p2)
  388. {
  389.     if ((p1->h - p2->h > 3) || (p2->h - p1->h > 3))
  390.         return(0);
  391.     if ((p1->v - p2->v > 3) || (p2->v - p1->v > 3))
  392.         return(0);
  393.  
  394.     return(1);
  395. }
  396.  
  397. void VidSync( void)
  398. {
  399.     long    a;
  400.     a = TickCount();            /* BYU LSC */
  401.     while (a == TickCount())
  402.         /* loop*/;    /* BYU LSC */
  403. }
  404.  
  405. void RGmousedown
  406.   (
  407.     GrafPtr wind,
  408.     Point *wherein
  409.   )
  410. {
  411.     unsigned long    lx,ly;        /* NCSA: SB */
  412.     char            thispaceforent[6];
  413.     short            i;
  414.     Point            where;
  415.     char            dum[32];
  416.  
  417.     where = *wherein;
  418.     if ((i = RGfindbywind(wind)) < 0)
  419.         return;
  420.  
  421.     if (!RGMwind[i]->ingin)
  422.     {
  423.     Point    anchor,current,last;
  424. #if 0                            /* BYU LSC - was "#ifndef MPW" */
  425.     long    TickCount();
  426. #endif MPW
  427.     long    tc;
  428.     short    x0,y0,x1,y1;
  429.     Rect    rect;
  430.     
  431.         SetPort(wind);
  432.     
  433.         last  = where;
  434.         current = where;
  435.         anchor = where;
  436.     
  437.         PenPat(PATTERN(qd.gray));    
  438.         PenMode(patXor);
  439.     
  440.         SetRect(&rect,0,0,0,0);
  441.     
  442.         while (StillDown())
  443.         {
  444.             GetMouse(¤t);
  445.             if (inSplash(¤t,&anchor)) continue;
  446.             tc = TickCount();
  447.             while(TickCount() == tc)
  448.                 /* loop */;
  449.             VidSync();
  450.             FrameRect(&rect);
  451.     
  452.             if (anchor.v < current.v)
  453.             {
  454.                 rect.top = anchor.v;
  455.                 rect.bottom = current.v;
  456.             }
  457.             else
  458.             {
  459.                 rect.top = current.v;
  460.                 rect.bottom = anchor.v;
  461.             }
  462.     
  463.             if (anchor.h < current.h)
  464.             {
  465.                 rect.left = anchor.h;
  466.                 rect.right = current.h;
  467.             }
  468.             else
  469.             {
  470.                 rect.right = anchor.h;
  471.                 rect.left = current.h;
  472.             }
  473.     
  474.             FrameRect(&rect);
  475.             last = current;
  476.         }
  477.     
  478.         FrameRect(&rect);
  479.  
  480.         PenPat(PATTERN(qd.black));    
  481.         PenMode(patCopy);
  482.  
  483.         if (!inSplash(&anchor,¤t))
  484.         {
  485.             x0 = (short) ((long) rect.left * RGMwind[i]->xscale / RGMwind[i]->width );
  486.             y0 = (short) (RGMwind[i]->yscale -
  487.                     (long) rect.top * RGMwind[i]->yscale / RGMwind[i]->height);
  488.             x1 = (short) ((long) rect.right * RGMwind[i]->xscale / RGMwind[i]->width);
  489.             y1 = (short) (RGMwind[i]->yscale -
  490.                     (long) rect.bottom * RGMwind[i]->yscale / RGMwind[i]->height);
  491.             x1 = (x1 < x0+2) ? x0 + 4 : x1;
  492.             y0 = (y0 < y1+2) ? y1 + 4 : y0;
  493.  
  494.             VGzoom( i,
  495.                     x0 + RGMwind[i]->xorigin,
  496.                     y1 + RGMwind[i]->yorigin,
  497.                     x1 + RGMwind[i]->xorigin,
  498.                     y0 + RGMwind[i]->yorigin);
  499.  
  500.             VGpage(RGMwind[i]->vg);
  501.  
  502.             RGMwind[i]->xscale  = x1 - x0;
  503.             RGMwind[i]->yscale  = y0 - y1;
  504.             RGMwind[i]->xorigin = x0 + RGMwind[i]->xorigin;
  505.             RGMwind[i]->yorigin = y1 + RGMwind[i]->yorigin;
  506.  
  507.             while(!VGpred(RGMwind[i]->vg,RGMwind[i]->vg))
  508.                 Stask();
  509.             RGMlastclick = 0L;
  510.         }
  511.         else
  512.         {
  513.             if (RGMlastclick && ((RGMlastclick + GetDblTime()) > TickCount()))
  514.             {
  515.                 RGMwind[i]->xscale  = WINXMAX;    /* BYU LSC - need the "W" here */
  516.                 RGMwind[i]->yscale  = WINYMAX;    /* BYU LSC - need the "W" here */
  517.                 RGMwind[i]->xorigin = 0;
  518.                 RGMwind[i]->yorigin = 0;
  519.  
  520.                 VGzoom(i,0,0,WINXMAX-1,WINYMAX-1);    /* BYU LSC - need the "W" here */
  521.                 VGpage( RGMwind[i]->vg);
  522.                 while(!VGpred(RGMwind[i]->vg,RGMwind[i]->vg))
  523.                     Stask();
  524.                 RGMlastclick = 0L;
  525.             }
  526.             else RGMlastclick = TickCount();
  527.         }
  528.         return;
  529.     
  530.     }
  531.     
  532.     /* NCSA: SB */
  533.     /* NCSA: SB - These computations are being truncated and turned into signed ints. */
  534.     /* NCSA: SB - Just make sure everything is cast correctly, and were fine */
  535.     
  536.     lx = ((unsigned long)RGMwind[i]->xscale * (unsigned long)where.h)     /* NCSA: SB */
  537.             / (unsigned long)RGMwind[i]->width;                             /* NCSA: SB */
  538.     ly = (unsigned long)RGMwind[i]->yscale -                             /* NCSA: SB */
  539.         ((unsigned long)RGMwind[i]->yscale * (unsigned long)where.v) / (unsigned long)RGMwind[i]->height; /* NCSA: SB */
  540.  
  541.     VGgindata(RGMwind[i]->vg,(unsigned short) lx,(unsigned short)ly,' ',thispaceforent);    /* NCSA: SB */
  542.  
  543. #if 0                                                    /* BYU LSC - not needed */
  544. sprintf(dum,"GIN i: %d, vs: %d\015",i,RGMwind[i]->vs);    /* BYU 2.4.18 - changed \n to \015 */
  545. putln(dum);
  546. #endif                                                    /* BYU LSC - not needed */
  547.  
  548.     RSsendstring(RGMwind[i]->vs,thispaceforent,5);
  549.     sprintf(dum," \r\n");
  550.     RSsendstring(RGMwind[i]->vs,dum,3);
  551.     
  552.  
  553.     /*    RGMwind[i]->ingin = 0; */
  554.     unsetgraphcurs();
  555.     RGMlastclick = TickCount();
  556. }
  557.  
  558.  
  559. /*--------------------------------------------------------------------------*/
  560. /* NCSA: SB - RGMgrowme                                                        */
  561. /* This allows the TEK window to be grown like any other real window.        */
  562. /* The grow box is not shown on the screen, but it acts accordingly     - SMB    */
  563. /*--------------------------------------------------------------------------*/
  564. void    RGMgrowme(short myRGMnum,GrafPtr window, long *where, short modifiers)
  565. {
  566.     UNUSED_ARG(modifiers)
  567.     long size;
  568.     Rect SizRect;
  569.  
  570.     SetRect(&SizRect, 50, 50, 1500, 1500);            /* NCSA: SB - max size - arbitrary */
  571.  
  572.     if (where)
  573.     {        
  574.         size = GrowWindow(window, *(Point *) where, &SizRect);    
  575.         if (size != 0L)
  576.             {
  577.             SizeWindow(window, size & 0xffff, (size >> 16) & 0xffff, FALSE);
  578.             RGMwind[myRGMnum]->width   = window->portRect.right - window->portRect.left;        
  579.             RGMwind[myRGMnum]->height  = window->portRect.bottom - window->portRect.top;         
  580.             VGpage(RGMwind[myRGMnum]->vg);
  581.             InvalRect(&window->portRect);
  582.             RGupdate(window);
  583.             }
  584.         else
  585.             return;                            /* user skipped growing */
  586.     }
  587. }
  588.  
  589.